<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">

<title>class OpenSSL::Engine - openssl: Ruby Standard Library Documentation</title>


<script src="../js/navigation.js" defer></script>
<script src="../js/search.js" defer></script>
<script src="../js/search_index.js" defer></script>
<script src="../js/searcher.js" defer></script>
<script src="../js/darkfish.js" defer></script>

<script src="../js/jquery-3.2.0.min.js"></script>

<script src="../js/vue.min.js"></script>
<script src="../js/js.cookie.min.js"></script>

<link href="../css/fonts.css" rel="stylesheet">
<link id='rdoccss' href="../css/rdoc.css" rel="stylesheet">
<link href="../css/carbon17.css" rel="stylesheet">

<script type="text/javascript">
  var rdoc_rel_prefix = "../";
  var index_rel_prefix = "../";
  var darkModeCsseHref = "../css/rdoc-dm.css"
  var defaultModeCssHref = "../css/rdoc.css"
  // var cssDarkmode = Cookies.get('darkmode');
  
  if( Cookies.get("darkmode") == "true") {
	$('#rdoccss').attr("href", darkModeCsseHref);
}

//  https://cssdeck.com/blog/simple-jquery-stylesheet-switcher/

document.write('<style type="text/css">body{display:none}</style>');

</script>


</head>
<body id="top" role="document" class="class">
  <!-- this is class.html -->

  <div id='actionbar' >
    <div class='wrapper mdiv'>
      <ul class='grids g0'></ul>
    </div> 
    <!-- VERSION HEADER for 3.3.0.preview2 NOT FOUND -->
  </div> <!-- end action bar -->

  <div class='wrapper hdiv'>

    


    <nav id='vapp' role="navigation">
    <div id="project-navigation">
      <div id="home-section" role="region" title="Quick navigation" class="nav-section">
  <h2><a href="../index.html" rel="home">Home</a></h2>

  <div id="table-of-contents-navigation"  >
    <a href="../table_of_contents.html#pages">Pages</a>
    <a href="../table_of_contents.html#classes">Classes</a>
    <a href="../table_of_contents.html#methods">Methods</a>
  </div>
</div>

      <div id="search-section" role="search" class="project-section initially-hidden">
  <form action="#" method="get" accept-charset="utf-8">
    <div id="search-field-wrapper">
      <input id="search-field" role="combobox" aria-label="Search"
             aria-autocomplete="list" aria-controls="search-results"
             type="text" name="search" placeholder="Search" spellcheck="false"
             title="Type to search, Up and Down to navigate, Enter to load">
    </div>

    <ul id="search-results" aria-label="Search Results"
        aria-busy="false" aria-expanded="false"
        aria-atomic="false" class="initially-hidden"></ul>
  </form>
</div>

    </div>


    

    <button id='toggleThing' @click="toggleNav()" >Show/hide navigation</button>
    <div :class="isOpen ? 'block' : 'hidden' " id='toggleMe'>
      <div id="class-metadata">
        
        
<div id="parent-class-section" class="nav-section">
  <h3>Parent</h3>

  <p class="link">Object
</div>

        
        
        
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
  <h3>Methods</h3>

  <ul class="link-list" role="directory">
    <li ><a href="#method-c-by_id">::by_id</a>
    <li ><a href="#method-c-cleanup">::cleanup</a>
    <li ><a href="#method-c-engines">::engines</a>
    <li ><a href="#method-c-load">::load</a>
    <li ><a href="#method-i-cipher">#cipher</a>
    <li ><a href="#method-i-cmds">#cmds</a>
    <li ><a href="#method-i-ctrl_cmd">#ctrl_cmd</a>
    <li ><a href="#method-i-digest">#digest</a>
    <li ><a href="#method-i-finish">#finish</a>
    <li ><a href="#method-i-id">#id</a>
    <li ><a href="#method-i-inspect">#inspect</a>
    <li ><a href="#method-i-load_private_key">#load_private_key</a>
    <li ><a href="#method-i-load_public_key">#load_public_key</a>
    <li ><a href="#method-i-name">#name</a>
    <li ><a href="#method-i-set_default">#set_default</a>
  </ul>
</div>

      </div>
     </div>
    </nav>


    <div id='extraz'><div class='adzbox-index'  >
      
     </div>         
    </div>

    <main role="main" aria-labelledby="class-OpenSSL::Engine">
    <h1 id="class-OpenSSL::Engine" class="class">
      class OpenSSL::Engine
    </h1>

    <section class="description">
    
<p>This class is the access to openssl’s ENGINE cryptographic module implementation.</p>

<p>See also, <a href="https://www.openssl.org/docs/crypto/engine.html">www.openssl.org/docs/crypto/engine.html</a></p>

    </section>

      <section id="5Buntitled-5D" class="documentation-section">





                <section id="public-class-5Buntitled-5D-method-details" class="method-section">
                <header>
                <h3>Public Class Methods</h3>
                </header>

                  <div id="method-c-by_id" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          OpenSSL::Engine.by_id(name) &rarr; engine
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Fetches the engine as specified by the <em>id</em> String.</p>

<pre>OpenSSL::Engine.by_id(&quot;openssl&quot;)
 =&gt; #&lt;OpenSSL::Engine id=&quot;openssl&quot; name=&quot;Software engine support&quot;&gt;</pre>

<p>See <a href="Engine.html#method-c-engines"><code>OpenSSL::Engine.engines</code></a> for the currently loaded engines.</p>

                              <div class="method-source-code" id="by_id-source">
            <pre>static VALUE
ossl_engine_s_by_id(VALUE klass, VALUE id)
{
    ENGINE *e;
    VALUE obj;

    StringValueCStr(id);
    ossl_engine_s_load(1, &amp;id, klass);
    obj = NewEngine(klass);
    if(!(e = ENGINE_by_id(RSTRING_PTR(id))))
        ossl_raise(eEngineError, NULL);
    SetEngine(obj, e);
    if(rb_block_given_p()) rb_yield(obj);
    if(!ENGINE_init(e))
        ossl_raise(eEngineError, NULL);
    ENGINE_ctrl(e, ENGINE_CTRL_SET_PASSWORD_CALLBACK,
                0, NULL, (void(*)(void))ossl_pem_passwd_cb);
    ossl_clear_error();

    return obj;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-c-cleanup" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          OpenSSL::Engine.cleanup
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>It is only necessary to run cleanup when engines are loaded via <a href="Engine.html#method-c-load"><code>OpenSSL::Engine.load</code></a>. However, running cleanup before exit is recommended.</p>

<p>Note that this is needed and works only in <a href="../OpenSSL.html"><code>OpenSSL</code></a> &lt; 1.1.0.</p>

                              <div class="method-source-code" id="cleanup-source">
            <pre>static VALUE
ossl_engine_s_cleanup(VALUE self)
{
#if defined(LIBRESSL_VERSION_NUMBER) || OPENSSL_VERSION_NUMBER &lt; 0x10100000
    ENGINE_cleanup();
#endif
    return Qnil;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-c-engines" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          OpenSSL::Engine.engines &rarr; [engine, ...]
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns an array of currently loaded engines.</p>

                              <div class="method-source-code" id="engines-source">
            <pre>static VALUE
ossl_engine_s_engines(VALUE klass)
{
    ENGINE *e;
    VALUE ary, obj;

    ary = rb_ary_new();
    for(e = ENGINE_get_first(); e; e = ENGINE_get_next(e)){
        obj = NewEngine(klass);
        /* Need a ref count of two here because of ENGINE_free being
         * called internally by OpenSSL when moving to the next ENGINE
         * and by us when releasing the ENGINE reference */
        ENGINE_up_ref(e);
        SetEngine(obj, e);
        rb_ary_push(ary, obj);
    }

    return ary;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-c-load" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          OpenSSL::Engine.load(name = nil)
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>This method loads engines. If <em>name</em> is nil, then all builtin engines are loaded. Otherwise, the given <em>name</em>, as a String,  is loaded if available to your runtime, and returns true. If <em>name</em> is not found, then nil is returned.</p>

                              <div class="method-source-code" id="load-source">
            <pre>static VALUE
ossl_engine_s_load(int argc, VALUE *argv, VALUE klass)
{
    VALUE name;

    rb_scan_args(argc, argv, &quot;01&quot;, &amp;name);
    if(NIL_P(name)){
        ENGINE_load_builtin_engines();
        return Qtrue;
    }
    StringValueCStr(name);
#ifdef HAVE_ENGINE_LOAD_DYNAMIC
    OSSL_ENGINE_LOAD_IF_MATCH(dynamic, DYNAMIC);
#endif
#ifndef OPENSSL_NO_STATIC_ENGINE
#ifdef HAVE_ENGINE_LOAD_4758CCA
    OSSL_ENGINE_LOAD_IF_MATCH(4758cca, 4758CCA);
#endif
#ifdef HAVE_ENGINE_LOAD_AEP
    OSSL_ENGINE_LOAD_IF_MATCH(aep, AEP);
#endif
#ifdef HAVE_ENGINE_LOAD_ATALLA
    OSSL_ENGINE_LOAD_IF_MATCH(atalla, ATALLA);
#endif
#ifdef HAVE_ENGINE_LOAD_CHIL
    OSSL_ENGINE_LOAD_IF_MATCH(chil, CHIL);
#endif
#ifdef HAVE_ENGINE_LOAD_CSWIFT
    OSSL_ENGINE_LOAD_IF_MATCH(cswift, CSWIFT);
#endif
#ifdef HAVE_ENGINE_LOAD_NURON
    OSSL_ENGINE_LOAD_IF_MATCH(nuron, NURON);
#endif
#ifdef HAVE_ENGINE_LOAD_SUREWARE
    OSSL_ENGINE_LOAD_IF_MATCH(sureware, SUREWARE);
#endif
#ifdef HAVE_ENGINE_LOAD_UBSEC
    OSSL_ENGINE_LOAD_IF_MATCH(ubsec, UBSEC);
#endif
#ifdef HAVE_ENGINE_LOAD_PADLOCK
    OSSL_ENGINE_LOAD_IF_MATCH(padlock, PADLOCK);
#endif
#ifdef HAVE_ENGINE_LOAD_CAPI
    OSSL_ENGINE_LOAD_IF_MATCH(capi, CAPI);
#endif
#ifdef HAVE_ENGINE_LOAD_GMP
    OSSL_ENGINE_LOAD_IF_MATCH(gmp, GMP);
#endif
#ifdef HAVE_ENGINE_LOAD_GOST
    OSSL_ENGINE_LOAD_IF_MATCH(gost, GOST);
#endif
#endif
#ifdef HAVE_ENGINE_LOAD_CRYPTODEV
    OSSL_ENGINE_LOAD_IF_MATCH(cryptodev, CRYPTODEV);
#endif
    OSSL_ENGINE_LOAD_IF_MATCH(openssl, OPENSSL);
    rb_warning(&quot;no such builtin loader for `%&quot;PRIsVALUE&quot;&#39;&quot;, name);
    return Qnil;
}</pre>
                              </div>
                            </div>


                          </div>

                          </section>

                <section id="public-instance-5Buntitled-5D-method-details" class="method-section">
                <header>
                <h3>Public Instance Methods</h3>
                </header>

                  <div id="method-i-cipher" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          cipher(name) &rarr; OpenSSL::Cipher
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns a new instance of <a href="Cipher.html"><code>OpenSSL::Cipher</code></a> by <em>name</em>, if it is available in this engine.</p>

<p>An <a href="Engine/EngineError.html"><code>EngineError</code></a> will be raised if the cipher is unavailable.</p>

<pre>e = OpenSSL::Engine.by_id(&quot;openssl&quot;)
 =&gt; #&lt;OpenSSL::Engine id=&quot;openssl&quot; name=&quot;Software engine support&quot;&gt;
e.cipher(&quot;RC4&quot;)
 =&gt; #&lt;OpenSSL::Cipher:0x007fc5cacc3048&gt;</pre>

                              <div class="method-source-code" id="cipher-source">
            <pre>static VALUE
ossl_engine_get_cipher(VALUE self, VALUE name)
{
    ENGINE *e;
    const EVP_CIPHER *ciph, *tmp;
    int nid;

    tmp = EVP_get_cipherbyname(StringValueCStr(name));
    if(!tmp) ossl_raise(eEngineError, &quot;no such cipher `%&quot;PRIsVALUE&quot;&#39;&quot;, name);
    nid = EVP_CIPHER_nid(tmp);
    GetEngine(self, e);
    ciph = ENGINE_get_cipher(e, nid);
    if(!ciph) ossl_raise(eEngineError, NULL);

    return ossl_cipher_new(ciph);
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-cmds" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          cmds &rarr; [[&quot;name&quot;, &quot;description&quot;, &quot;flags&quot;], ...]
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns an array of command definitions for the current engine</p>

                              <div class="method-source-code" id="cmds-source">
            <pre>static VALUE
ossl_engine_get_cmds(VALUE self)
{
    ENGINE *e;
    const ENGINE_CMD_DEFN *defn, *p;
    VALUE ary, tmp;

    GetEngine(self, e);
    ary = rb_ary_new();
    if ((defn = ENGINE_get_cmd_defns(e)) != NULL){
        for (p = defn; p-&gt;cmd_num &gt; 0; p++){
            tmp = rb_ary_new();
            rb_ary_push(tmp, rb_str_new2(p-&gt;cmd_name));
            rb_ary_push(tmp, rb_str_new2(p-&gt;cmd_desc));
            rb_ary_push(tmp, ossl_engine_cmd_flag_to_name(p-&gt;cmd_flags));
            rb_ary_push(ary, tmp);
        }
    }

    return ary;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-ctrl_cmd" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          ctrl_cmd(command, value = nil) &rarr; engine
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Sends the given <em>command</em> to this engine.</p>

<p>Raises an <a href="Engine/EngineError.html"><code>EngineError</code></a> if the command fails.</p>

                              <div class="method-source-code" id="ctrl_cmd-source">
            <pre>static VALUE
ossl_engine_ctrl_cmd(int argc, VALUE *argv, VALUE self)
{
    ENGINE *e;
    VALUE cmd, val;
    int ret;

    GetEngine(self, e);
    rb_scan_args(argc, argv, &quot;11&quot;, &amp;cmd, &amp;val);
    ret = ENGINE_ctrl_cmd_string(e, StringValueCStr(cmd),
                                 NIL_P(val) ? NULL : StringValueCStr(val), 0);
    if (!ret) ossl_raise(eEngineError, NULL);

    return self;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-digest" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          digest(name) &rarr; OpenSSL::Digest
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns a new instance of <a href="Digest.html"><code>OpenSSL::Digest</code></a> by <em>name</em>.</p>

<p>Will raise an <a href="Engine/EngineError.html"><code>EngineError</code></a> if the digest is unavailable.</p>

<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">by_id</span>(<span class="ruby-string">&quot;openssl&quot;</span>)
  <span class="ruby-comment">#=&gt; #&lt;OpenSSL::Engine id=&quot;openssl&quot; name=&quot;Software engine support&quot;&gt;</span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">digest</span>(<span class="ruby-string">&quot;SHA1&quot;</span>)
  <span class="ruby-comment">#=&gt; #&lt;OpenSSL::Digest: da39a3ee5e6b4b0d3255bfef95601890afd80709&gt;</span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">digest</span>(<span class="ruby-string">&quot;zomg&quot;</span>)
  <span class="ruby-comment">#=&gt; OpenSSL::Engine::EngineError: no such digest `zomg&#39;</span>
</pre>

                              <div class="method-source-code" id="digest-source">
            <pre>static VALUE
ossl_engine_get_digest(VALUE self, VALUE name)
{
    ENGINE *e;
    const EVP_MD *md, *tmp;
    int nid;

    tmp = EVP_get_digestbyname(StringValueCStr(name));
    if(!tmp) ossl_raise(eEngineError, &quot;no such digest `%&quot;PRIsVALUE&quot;&#39;&quot;, name);
    nid = EVP_MD_nid(tmp);
    GetEngine(self, e);
    md = ENGINE_get_digest(e, nid);
    if(!md) ossl_raise(eEngineError, NULL);

    return ossl_digest_new(md);
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-finish" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          finish &rarr; nil
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Releases all internal structural references for this engine.</p>

<p>May raise an <a href="Engine/EngineError.html"><code>EngineError</code></a> if the engine is unavailable</p>

                              <div class="method-source-code" id="finish-source">
            <pre>static VALUE
ossl_engine_finish(VALUE self)
{
    ENGINE *e;

    GetEngine(self, e);
    if(!ENGINE_finish(e)) ossl_raise(eEngineError, NULL);

    return Qnil;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-id" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          id &rarr; string
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Gets the id for this engine.</p>

<pre class="ruby"><span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">load</span>
<span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">engines</span> <span class="ruby-comment">#=&gt; [#&lt;OpenSSL::Engine#&gt;, ...]</span>
<span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">engines</span>.<span class="ruby-identifier">first</span>.<span class="ruby-identifier">id</span>
  <span class="ruby-comment">#=&gt; &quot;rsax&quot;</span>
</pre>

                              <div class="method-source-code" id="id-source">
            <pre>static VALUE
ossl_engine_get_id(VALUE self)
{
    ENGINE *e;
    GetEngine(self, e);
    return rb_str_new2(ENGINE_get_id(e));
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-inspect" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          inspect &rarr; string
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Pretty prints this engine.</p>

                              <div class="method-source-code" id="inspect-source">
            <pre>static VALUE
ossl_engine_inspect(VALUE self)
{
    ENGINE *e;

    GetEngine(self, e);
    return rb_sprintf(&quot;#&lt;%&quot;PRIsVALUE&quot; id=\&quot;%s\&quot; name=\&quot;%s\&quot;&gt;&quot;,
                      rb_obj_class(self), ENGINE_get_id(e), ENGINE_get_name(e));
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-load_private_key" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          load_private_key(id = nil, data = nil) &rarr; OpenSSL::PKey
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Loads the given private key identified by <em>id</em> and <em>data</em>.</p>

<p>An <a href="Engine/EngineError.html"><code>EngineError</code></a> is raised of the <a href="PKey.html"><code>OpenSSL::PKey</code></a> is unavailable.</p>

                              <div class="method-source-code" id="load_private_key-source">
            <pre>static VALUE
ossl_engine_load_privkey(int argc, VALUE *argv, VALUE self)
{
    ENGINE *e;
    EVP_PKEY *pkey;
    VALUE id, data, obj;
    char *sid, *sdata;

    rb_scan_args(argc, argv, &quot;02&quot;, &amp;id, &amp;data);
    sid = NIL_P(id) ? NULL : StringValueCStr(id);
    sdata = NIL_P(data) ? NULL : StringValueCStr(data);
    GetEngine(self, e);
    pkey = ENGINE_load_private_key(e, sid, NULL, sdata);
    if (!pkey) ossl_raise(eEngineError, NULL);
    obj = ossl_pkey_new(pkey);
    OSSL_PKEY_SET_PRIVATE(obj);

    return obj;
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-load_public_key" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          load_public_key(id = nil, data = nil) &rarr; OpenSSL::PKey
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Loads the given public key identified by <em>id</em> and <em>data</em>.</p>

<p>An <a href="Engine/EngineError.html"><code>EngineError</code></a> is raised of the <a href="PKey.html"><code>OpenSSL::PKey</code></a> is unavailable.</p>

                              <div class="method-source-code" id="load_public_key-source">
            <pre>static VALUE
ossl_engine_load_pubkey(int argc, VALUE *argv, VALUE self)
{
    ENGINE *e;
    EVP_PKEY *pkey;
    VALUE id, data;
    char *sid, *sdata;

    rb_scan_args(argc, argv, &quot;02&quot;, &amp;id, &amp;data);
    sid = NIL_P(id) ? NULL : StringValueCStr(id);
    sdata = NIL_P(data) ? NULL : StringValueCStr(data);
    GetEngine(self, e);
    pkey = ENGINE_load_public_key(e, sid, NULL, sdata);
    if (!pkey) ossl_raise(eEngineError, NULL);

    return ossl_pkey_new(pkey);
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-name" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          name &rarr; string
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Get the descriptive name for this engine.</p>

<pre class="ruby"><span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">load</span>
<span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">engines</span> <span class="ruby-comment">#=&gt; [#&lt;OpenSSL::Engine#&gt;, ...]</span>
<span class="ruby-constant">OpenSSL</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">engines</span>.<span class="ruby-identifier">first</span>.<span class="ruby-identifier">name</span>
  <span class="ruby-comment">#=&gt; &quot;RSAX engine support&quot;</span>
</pre>

                              <div class="method-source-code" id="name-source">
            <pre>static VALUE
ossl_engine_get_name(VALUE self)
{
    ENGINE *e;
    GetEngine(self, e);
    return rb_str_new2(ENGINE_get_name(e));
}</pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-set_default" class="method-detail ">
                      <div class="method-heading">
                        <span class="method-callseq">
                          set_default(flag)
                              </span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Set the defaults for this engine with the given <em>flag</em>.</p>

<p>These flags are used to control combinations of algorithm methods.</p>

<p><em>flag</em> can be one of the following, other flags are available depending on your OS.</p>
<dl class="rdoc-list label-list"><dt>All flags
<dd>
<p>0xFFFF</p>
</dd><dt>No flags
<dd>
<p>0x0000</p>
</dd></dl>

<p>See also &lt;openssl/engine.h&gt;</p>

                              <div class="method-source-code" id="set_default-source">
            <pre>static VALUE
ossl_engine_set_default(VALUE self, VALUE flag)
{
    ENGINE *e;
    int f = NUM2INT(flag);

    GetEngine(self, e);
    ENGINE_set_default(e, f);

    return Qtrue;
}</pre>
                              </div>
                            </div>


                          </div>

                          </section>

              </section>
              </main>



            </div>  <!--  class='wrapper hdiv' -->


<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a></p>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.4.0.</p>
<p>Based on <a href="https://github.com/ged/darkfish/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.</p>

  
    <p><p><a href="https://ruby-doc.org">Ruby-doc.org</a> is provided by <a href="https://jamesbritt.com">James Britt</a> and <a href="https://neurogami.com">Neurogami</a>. </p><p><a href="https://jamesbritt.bandcamp.com/">Hack your world.  Feed your head.  Live curious</a>.</p>
</p>
  
  </footer>

<script type="text/javascript">


  let ads  = $("#carbonads-container").children().detach();


  function swapMode() {
    var cookieName = 'darkmode';
    var cssDarkmode = Cookies.get(cookieName);
    console.log("***** swapMode! " + cssDarkmode + " *****");


    if (cssDarkmode == "true") {
      console.log("We have dark mode, set the css to light ...");
      $('#rdoccss').attr("href", defaultModeCssHref);
      $('#cssSelect').text("Dark mode");
      cssDarkmode = "false";
      console.log("swapMode! Now set cookie to " + cssDarkmode);
      Cookies.set(cookieName, cssDarkmode);

    } else {
      console.log("We not have dark mode, set the css to dark ...");
      $('#rdoccss').attr("href", darkModeCsseHref);
      $('#cssSelect').text("Light mode");
      cssDarkmode = "true";
      console.log("swapMode! Now set cookie to " + cssDarkmode);
      Cookies.set(cookieName, cssDarkmode);

    }

    console.log("  --------------- ");
  }


const vueCssApp = new Vue({
el: '#menubar',
data: {
isDark: false
},
methods: {
toggleClass: function(event){
this.isDark = !this.isDark;
}
}
})

const vueApp = new Vue({
el: '#vapp',
data: { 
isOpen: true
},

mounted() {
this.handleResize();
this.manage_mob_classes();
window.addEventListener('resize', this.handleResize)
//this.isOpen !=  (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent));
},
destroyed() {
window.removeEventListener('resize', this.handleResize)
},
created() {
//manage_mob_classes();
},

methods : {
isMobile() {
  return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent));
},

  handleResize() {
    if (!this.isMobile()) {
      this.isOpen = window.innerWidth > 800;
    }
  },

  manage_mob_classes() {
    if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
      $("nav").addClass("mob_nav");
      $("main").addClass("mob_main");
      $("#extraz").addClass("mob_extraz");
      $("#carbonads-container").addClass("mob_carbonads-container");
      this.isOpen  = false;
    } else {
      $("nav").removeClass("mob_nav") 
        $("main").removeClass("mob_main");
      $("#extraz").removeClass("mob_extraz");
      $("#carbonads-container").removeClass("mob_carbonads-container");
      this.isOpen  = true;
    }
  },

  toggleNav() {
    this.isOpen =! this.isOpen ;
    // alert("Toggle nav!");
    console.log("toggleNav() click: " + this.isOpen );
  }
}
})

$("#carbonads-container").append(ads);


$(function() {

    var darkmode = Cookies.get("darkmode");
    console.log("Document ready: " + darkmode);

    if ( darkmode  == "true" ) {
      $('#cssSelect').text("Light mode");
    } else {
      $('#cssSelect').text("Dark mode");
     }

    $('body').css('display','block');
    });

</script>

    
  </body> 
</html>

